Lua 之 middleclass 详解

发表于 更新于 分类于 阅读次数： 442
middleclass 是 Lua 模拟实现 oop 编程的类库，本文详细的分析了 middleclass 实现 oop 编程的过程。

A simple OOP library for Lua. It has inheritance, metamethods (operators), class variables and weak mixin support.
https://github.com/kikito/middleclass

前言

本文逐步的分析了 middleclass 模拟 oop 编程的过程。但是建议读者在看这篇文章之前对 Lua 的元表和元方法有一定的了解。

类定义

新建类定义

创建一个 modulde，创建一个空白类定义对象，类定义对象需记录自己的 name.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
---middleclass---
local middleclass = {}

local function _createClass(name)
	local aClass = {
		name = name,	-- 类名
	}
	return aClass
end

function middleclass.class(name)
	return _createClass(name)
end

return middleclass
复制

测试：

1
2
3
4
5
6
7
8
---Animal---
local Class = require 'middleclass'

local Animal = Class.class('Animal')

print(Animal)	-- table: 00B99B68

return Animal
复制

添加__tostring 函数

目前执行 print (Animal) 的时候，输出的是 table: 00B99B68 (类型：指针地址)
可以让 print 的时候输出更友好的内容，比如 class Animal

解决方案
给新建类统一添加__tostring 函数
print (Animal) 时，会隐式调用 tostring (Animal)，接着会尝试调用 getmetatable (Animal).__tostring (Animal)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
---middleclass---
local middleclass = {}

local function _tostring(aClass)
	return 'class '..aClass.name
end

local function _createClass(name)
	local aClass = {
		name = name,	-- 类名
	}

	setmetatable(aClass, {
		__tostring = _tostring, 	--设置aClass的元方法__tostring
	})

	return aClass
end

function middleclass.class(name)
	return _createClass(name)
end

return middleclass
复制

测试：

1
2
3
4
5
6
7
8
---Animal---
local Class = require 'middleclass'

local Animal = Class.class('Animal')

print(Animal)	-- class Animal

return Animal
复制

模拟 Class 关键字

目前创建一个类定义对象要调用如下写法 Class.class (classname)
可以改为模拟 oop Class 关键字的风格 Class (classname)

解决方案
给 middleclass 添加__call 函数
把一个 table 当做函数调用时，会去尝试执行该 table 的 metatable 中的__call 函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
---middleclass---
local middleclass = {}

local function _tostring(aClass)
	return 'class '..aClass.name
end

local function _createClass(name)
	local aClass = {
		name = name,	-- 类名
	}

	setmetatable(aClass, {
		__tostring = _tostring, 	--设置aClass的元方法__tostring
	})

	return aClass
end

function middleclass.class(name)
	return _createClass(name)
end

-- 模拟oop class关键字的风格
setmetatable(middleclass, { __call = function(_, ...) return middleclass.class(...) end} )

return middleclass
复制

测试：

1
2
3
4
5
6
7
8
---Animal---
local Class = require 'middleclass'

local Animal = Class('Animal')

print(Animal)	-- class Animal

return Animal
复制

实例化

导入

A 继承 B 的效果是什么？我们粗略的理解为，A 不经显式声明就可以使用 B 的函数 / 变量。
middleclass 使用了一个粗暴的手段：把父类中的所有属性都拷贝到子类中。middleclass 没有把这种手段称为【继承】，而是借用了另外一个术语【导入（Include）】，这时父类被称为【Mixin】。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
---middleclass---
local middleclass = {}

local function _tostring(aClass)
	return 'class '..aClass.name
end

local function _createClass(name)
	local aClass = {
		name = name,	-- 类名
	}

	setmetatable(aClass, {
		__tostring = _tostring, 	--设置aClass的元方法__tostring
	})

	return aClass
end

-- 导入mixin
local function _includeMixin(aClass, mixin) 
	assert(type(mixin)=='table', 'mixin must be a table.')

	-- 将mixin的所有值复制到aClass中
	-- 除了included，这个名字默认是保留给mixin的回调
	for name,method in pairs(mixin) do
		if name ~= 'included' then
			aClass[name] = method
		end
	end

	-- 执行mixin included回调
	if type(mixin.included) == 'function' then
		mixin:included(aClass)
	end

	return aClass
end

function middleclass.class(name)
	return _createClass(name)
end

-- 模拟oop class关键字的风格
setmetatable(middleclass, { __call = function(_, ...) return middleclass.class(...) end} )

return middleclass
复制

实例化

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
---middleclass---
local middleclass = {}

local function _tostring(aClass)
	return 'class '..aClass.name
end

local function _createClass(name)
	local aClass = {
		name = name,	-- 类名
	}

	setmetatable(aClass, {
		__tostring = _tostring, 	--设置aClass的元方法__tostring
	})

	return aClass
end

-- 导入mixin
local function _includeMixin(aClass, mixin) 
	assert(type(mixin)=='table', 'mixin must be a table.')

	-- 将mixin的所有值复制到aClass中
	-- 除了included，这个名字默认是保留给mixin的回调
	for name,method in pairs(mixin) do
		if name ~= 'included' then
			aClass[name] = method
		end
	end

	-- 执行mixin included回调
	if type(mixin.included) == 'function' then
		mixin:included(aClass)
	end

	return aClass
end

--创建实例
local function allocate(aClass)
	assert(type(aClass) == 'table', "Make sure that you are using 'Class:allocate' instead of 'Class.allocate'")
	return { class = aClass, initialize = function (aClass, ...) end }
end

--创建实例并初始化
local function new(aClass)
	assert(type(aClass) == 'table', "Make sure that you are using 'Class:new' instead of 'Class.new'")
	local instance = aClass:allocate()
	instance:initialize(...)
	return instance
end

function middleclass.class(name)
	return _createClass(name)
end

-- 模拟oop class关键字的风格
setmetatable(middleclass, { __call = function(_, ...) return middleclass.class(...) end} )

return middleclass
复制

DefaultMixin

目前 middleclass 出现了两类函数：工具函数和 class 专用函数
class 专用函数，比如，每个新创建的 class 都应拥有实例化的能力。class 专用函数被打包到一个叫 DefaultMixin 表中，通过 include 方便的复制给每个新建 class

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
---middleclass---
local middleclass = {}

local function _tostring(aClass)
	return 'class '..aClass.name
end

local function _createClass(name)
	local aClass = {
		name = name,	-- 类名
	}

	setmetatable(aClass, {
		__tostring = _tostring, 	--设置aClass的元方法__tostring
	})

	return aClass
end

-- 导入mixin
local function _includeMixin(aClass, mixin) 
	assert(type(mixin)=='table', 'mixin must be a table.')

	-- 将mixin的所有值复制到aClass中
	-- 除了included，这个名字默认是保留给mixin的回调
	for name,method in pairs(mixin) do
		if name ~= 'included' then
			aClass[name] = method
		end
	end

	-- 执行mixin included回调
	if type(mixin.included) == 'function' then
		mixin:included(aClass)
	end

	return aClass
end

local DefaultMixin = {
	--初始化
	initialize = function(instance, ...) end,

	--创建实例
	allocate = function(aClass)
		assert(type(aClass) == 'table', "Make sure that you are using 'Class:allocate' instead of 'Class.allocate'")
		return { class = aClass, initialize = aClass.initialize }
	end,

	--创建实例并初始化
	new = function(aClass, ...)
		assert(type(aClass) == 'table', "Make sure that you are using 'Class:new' instead of 'Class.new'")
		local instance = aClass:allocate()
		instance:initialize(...)
		return instance
	end,
}

function middleclass.class(name)
	return _includeMixin(_createClass(name), DefaultMixin)
end

-- 模拟oop class关键字的风格
setmetatable(middleclass, { __call = function(_, ...) return middleclass.class(...) end} )

return middleclass
复制
1
2
3
4
5
6
7
8
9
10
---Animal---
local Class = require 'middleclass'

local Animal = Class('Animal')

function Animal:initialize(name)
	print('Animal initialize name:'.. name)
end

return Animal
复制

测试：

1
2
3
4
5
6
---test---
local Animal = require 'Animal'

local dog = Animal:new('dog')	-- Animal initialize name:dog

return dog
复制

静态 vs 成员

lua 本身没有静态与成员函数之分。
middleclass 则定义的更为细致，更为贴近 oop 惯例。

classinstance
静态函数可调用不可调用
成员函数可调用（有什么意义？）可调用
  • class 可调用成员函数的意义？必不可少的功能，不然怎么通过 super 来调用父类的成员函数。为实现上述目的，middleclass 对某 class 上定义的函数进行了分组
  • 也就是说，函数的声明都是在 class 级别进行的
    1. class.static : 只有 class 可以调用的函数
    2. class.__instanceDict : instance 所调用的函数

static 表

上面章节的 class 专用函数，比如实例化函数，middleclass 将其当做静态函数处理；在别的语言中，实例化功能可能埋藏在语言实现的底层，以语言关键字的形式出现，而非静态函数。是的，关键就在于此：middleclass 用静态函数来模拟 new 这个关键字。
middleclass 用 class.static 来记录 class 中的静态函数，并将 class.static 设为 class 元表中__index 的值中。class 得以调用 class.static 中的函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
---middleclass---
local middleclass = {}

local function _tostring(aClass)
	return 'class '..aClass.name
end

local function _createClass(name)
	local aClass = {
		name = name,	-- 类名
		static = {},	-- 静态函数表，包括一些关键字比如new，在middleclass中是用静态函数来模拟
	}

	setmetatable(aClass, {
		__tostring = _tostring, 	-- 设置aClass的元方法__tostring
		__index = aClass.static,	-- class的索引表设为其static表，如此class对象可以访问其static表中的函数
	})

	return aClass
end

-- 导入mixin
local function _includeMixin(aClass, mixin)
	assert(type(mixin)=='table', 'mixin must be a table.')

	-- 将mixin的所有值复制到aClass中
	-- 除了included，这个名字默认是保留给mixin的回调
	-- 还要排除static表，因为不能简单的记录static引用，这会覆盖aClass现有的static表
	for name,method in pairs(mixin) do
		if name ~= 'included' and name ~= 'static' then
			aClass[name] = method
		end
	end

	-- 把mixin.static表内容添加到aClass.static中
	for name,method in pairs(mixin.static or {}) do
		aClass.static[name] = method
	end

	-- 执行mixin included回调
	if type(mixin.included) == 'function' then
		mixin:included(aClass)
	end

	return aClass
end

local DefaultMixin = {
	--初始化
	initialize = function(instance, ...) end,

	static = {
		--创建实例
		allocate = function(aClass)
			assert(type(aClass) == 'table', "Make sure that you are using 'Class:allocate' instead of 'Class.allocate'")
			return { class = aClass, initialize = aClass.initialize }
		end,

		--创建实例并初始化
		new = function(aClass, ...)
			assert(type(aClass) == 'table', "Make sure that you are using 'Class:new' instead of 'Class.new'")
			local instance = aClass:allocate()
			instance:initialize(...)
			return instance
		end,
	},
}

function middleclass.class(name)
	return _includeMixin(_createClass(name), DefaultMixin)
end

-- 模拟oop class关键字的风格
setmetatable(middleclass, { __call = function(_, ...) return middleclass.class(...) end} )

return middleclass
复制

__instanceDict 表

middleclass 把新定义的函数，MyClass.func () 或者 MyClass:func ()，都通过__newindex 元函数记录在 class.__instanceDict 表中，然后在该 class 创建实例时，把__instanceDict 设为实例的 metatable 以及元表的__index 的值

  • 在 middlecalss 眼中，MyClass.func () 或者 MyClass:func () 都是 middleclass 机制中的成员函数
  • 在我们的应用层面，MyClass.func () 像静态函数一样使用，MyClass:func () 像成员函数一样使用 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
---middleclass---
local middleclass = {}

local function _propagateInstanceMethod(aClass, name, f) 
	-- 新定义的函数将被添加为成员函数
	aClass.__instanceDict[name] = f
end

local function _declareInstanceMethod(aClass, name, f) 
	_propagateInstanceMethod(aClass, name, f) 
end

local function _tostring(aClass)
	return 'class '..aClass.name
end

local function _createClass(name)
	local dict = {}
	dict.__index = dict

	local aClass = {
		name = name,	-- 类名
		static = {},	-- 静态函数表，包括一些关键字比如new，在middleclass中是用静态函数来模拟
		__instanceDict = dict,	-- 用作设为实例的metatable以及metatable的__index的值
	}

	-- aClass.static的__index行为: 从aClass.__instanceDict进行rawget
	-- 其实__instanceDict没有自己的metatable，从而没有__index表，任何对__instanceDict的get都是rawget
	setmetatable(aClass.static, {__index = function(_, k)
		return rawget(dict, k)
	end})

	setmetatable(aClass, {
		__tostring = _tostring, 	-- 设置aClass的元方法__tostring
		__index = aClass.static,	-- class的索引表设为其static表，如此class对象可以访问其static中的函数以及__instanceDict中的raw函数
		__newindex = _declareInstanceMethod,
	})

	return aClass
end

-- 导入mixin
local function _includeMixin(aClass, mixin)
	assert(type(mixin)=='table', 'mixin must be a table.')

	-- 将mixin的所有值复制到aClass中
	-- 除了included，这个名字默认是保留给mixin的回调
	-- 还要排除static表，因为不能简单的记录static引用，这会覆盖aClass现有的static表
	for name,method in pairs(mixin) do
		if name ~= 'included' and name ~= 'static' then
			aClass[name] = method	-- 记住现在这个操作会触发_declareInstanceMethod函数 
		end
	end

	-- 把mixin.static表内容添加到aClass.static中
	for name,method in pairs(mixin.static or {}) do
		aClass.static[name] = method
	end

	-- 执行mixin included回调
	if type(mixin.included) == 'function' then
		mixin:included(aClass)
	end

	return aClass
end

local DefaultMixin = {
	-- 预留虚函数: 初始化，可以当做构造函数来用
	initialize = function(instance, ...) end,

	static = {
		-- 创建实例
		allocate = function(aClass)
			assert(type(aClass) == 'table', "Make sure that you are using 'Class:allocate' instead of 'Class.allocate'")
			return setmetatable({ class = aClass }, aClass.__instanceDict)	-- class的__instanceDict表用作设为实例的metatable以及metatable的__index的值
		end,

		-- 创建实例并初始化
		new = function(aClass, ...)
			assert(type(aClass) == 'table', "Make sure that you are using 'Class:new' instead of 'Class.new'")
			local instance = aClass:allocate()
			instance:initialize(...)
			return instance
		end,
	},
}

function middleclass.class(name)
	return _includeMixin(_createClass(name), DefaultMixin)
end

-- 模拟oop class关键字的风格
setmetatable(middleclass, { __call = function(_, ...) return middleclass.class(...) end} )

return middleclass
复制

一些细节

  • 可以用 ClassA () 的写法来 new 一个实例
  • 实例对象的__tostring 元函数 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
---middleclass---
local middleclass = {}

local function _propagateInstanceMethod(aClass, name, f) 
	-- 新定义的函数将被添加为成员函数
	aClass.__instanceDict[name] = f
end

local function _declareInstanceMethod(aClass, name, f) 
	_propagateInstanceMethod(aClass, name, f) 
end

local function _tostring(aClass)
	return 'class '..aClass.name
end

local function _call(aClass, ...)
	return aClass:new(...)
end

local function _createClass(name)
	local dict = {}
	dict.__index = dict

	local aClass = {
		name = name,	-- 类名
		static = {},	-- 静态函数表，包括一些关键字比如new，在middleclass中是用静态函数来模拟
		__instanceDict = dict,	-- 用作设为实例的metatable以及metatable的__index的值
	}

	-- aClass.static的__index行为: 从aClass.__instanceDict进行rawget
	-- 其实__instanceDict没有自己的metatable，从而没有__index表，任何对__instanceDict的get都是rawget
	setmetatable(aClass.static, {__index = function(_, k)
		return rawget(dict, k)
	end})

	setmetatable(aClass, {
		__tostring = _tostring, 	-- 设置aClass的元方法__tostring
		__index = aClass.static,	-- class的索引表设为其static表，如此class对象可以访问其static中的函数以及__instanceDict中的raw函数
		__newindex = _declareInstanceMethod,
		__call = _call,	-- 让我们可以用 ClassA()的写法来创建实例
	})

	return aClass
end

-- 导入mixin
local function _includeMixin(aClass, mixin)
	assert(type(mixin)=='table', 'mixin must be a table.')

	-- 将mixin的所有值复制到aClass中
	-- 除了included，这个名字默认是保留给mixin的回调
	-- 还要排除static表，因为不能简单的记录static引用，这会覆盖aClass现有的static表
	for name,method in pairs(mixin) do
		if name ~= 'included' and name ~= 'static' then
			aClass[name] = method	-- 记住现在这个操作会触发_declareInstanceMethod函数 
		end
	end

	-- 把mixin.static表内容添加到aClass.static中
	for name,method in pairs(mixin.static or {}) do
		aClass.static[name] = method
	end

	-- 执行mixin included回调
	if type(mixin.included) == 'function' then
		mixin:included(aClass)
	end

	return aClass
end

local DefaultMixin = {
	-- 没有记录在static中的函数将在class导入DefaultMixin的时候
	-- 通过aClass[name] = func这样的语句触发 _declareInstanceMethod
	-- 从而记录到aClass.__instanceDict中
	-- 由于aClass.__instanceDict同时还是实例对象的metatable，所以下面的__tostring也将成为实例对象的元函数
	__tostring = function(instance)
		return "instance of " .. tostring(instance.class)
	end,

	-- 预留虚函数: 初始化，可以当做构造函数来用。所有实例共用一个函数对象即可。
	initialize = function(instance, ...) end,

	static = {
		-- 创建实例
		allocate = function(aClass)
			assert(type(aClass) == 'table', "Make sure that you are using 'Class:allocate' instead of 'Class.allocate'")
			return setmetatable({ class = aClass }, aClass.__instanceDict)	-- class的__instanceDict表用作设为实例的metatable以及metatable的__index的值
		end,

		-- 创建实例并初始化
		new = function(aClass, ...)
			assert(type(aClass) == 'table', "Make sure that you are using 'Class:new' instead of 'Class.new'")
			local instance = aClass:allocate()
			instance:initialize(...)
			return instance
		end,
	},
}

function middleclass.class(name)
	return _includeMixin(_createClass(name), DefaultMixin)
end

-- 模拟oop class关键字的风格
setmetatable(middleclass, { __call = function(_, ...) return middleclass.class(...) end} )

return middleclass
复制
1
2
3
4
5
6
7
8
9
10
---Animal---
local Class = require 'middleclass'

local Animal = Class('Animal')

function Animal:initialize(name)
	print('Animal initialize name:'.. name)
end

return Animal
复制

测试：

1
2
3
4
5
6
7
8
---test---
local Animal = require 'Animal'

local dog = Animal('dog')	-- Animal initialize name:dog

print(dog)	-- instance of class Animal

return dog
复制

继承

实现【继承】关键字

和 new 一样，middleclass 用静态函数 subclass 来模拟实现 extends 关键字

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
---middleclass---
local middleclass = {}

local function _propagateInstanceMethod(aClass, name, f)
	-- 创建子类的时候，父类中__instanceDict的__index会把子类中__instanceDict的__inex覆盖掉，这种情况需要过滤掉
	if name == '__index' then return end

	-- 新定义的函数将被添加为成员函数
	aClass.__instanceDict[name] = f
end

local function _declareInstanceMethod(aClass, name, f)
	_propagateInstanceMethod(aClass, name, f)
end

local function _tostring(aClass)
	return 'class '..aClass.name
end

local function _call(aClass, ...)
	return aClass:new(...)
end

local function _createClass(name, super)
	local dict = {}
	dict.__index = dict

	local aClass = {
		name = name,	-- 类名
		super = super, 	-- 父类
		static = {},	-- 静态函数表，包括一些关键字比如new，在middleclass中是用静态函数来模拟
		__instanceDict = dict,	-- 用作设为实例的metatable以及metatable的__index的值
		subclasses = setmetatable({}, {__mode='k'})	-- 子类表(弱键引用)，key是类，value为布尔
	}

	-- aClass.static的__index行为: 从aClass.__instanceDict进行rawget
	-- 其实__instanceDict没有自己的metatable，从而没有__index表，任何对__instanceDict的get都是rawget
	-- 如果有父类的话，还会尝试去父类(进而沿着继承链上所有类定义)的static/__instanceDict 中查询
	if super then
		setmetatable(aClass.static, {__index = function(_, k)
			return rawget(dict, k) or super.static[k]
		end})
	else
		setmetatable(aClass.static, {__index = function(_, k)
			return rawget(dict, k)
		end})
	end

	setmetatable(aClass, {
		__tostring = _tostring, 	-- 设置aClass的元方法__tostring
		__index = aClass.static,	-- class的索引表设为其static表，如此class对象可以访问其static中的函数以及__instanceDict中的raw函数
		__newindex = _declareInstanceMethod,
		__call = _call,	-- 让我们可以用 ClassA()的写法来创建实例
	})

	return aClass
end

-- 导入mixin
local function _includeMixin(aClass, mixin)
	assert(type(mixin)=='table', 'mixin must be a table.')

	-- 将mixin的所有值复制到aClass中
	-- 除了included，这个名字默认是保留给mixin的回调
	-- 还要排除static表，因为不能简单的记录static引用，这会覆盖aClass现有的static表
	for name,method in pairs(mixin) do
		if name ~= 'included' and name ~= 'static' then
			aClass[name] = method	-- 记住现在这个操作会触发_declareInstanceMethod函数
		end
	end

	-- 把mixin.static表内容添加到aClass.static中
	for name,method in pairs(mixin.static or {}) do
		aClass.static[name] = method
	end

	-- 执行mixin included回调
	if type(mixin.included) == 'function' then
		mixin:included(aClass)
	end

	return aClass
end

local DefaultMixin = {
	-- 没有记录在static中的函数将在class导入DefaultMixin的时候
	-- 通过aClass[name] = func这样的语句触发 _declareInstanceMethod
	-- 从而记录到aClass.__instanceDict中
	-- 由于aClass.__instanceDict同时还是实例对象的metatable，所以下面的__tostring也将成为实例对象的元函数
	__tostring = function(instance)
		return "instance of " .. tostring(instance.class)
	end,

	-- 预留虚函数: 初始化，可以当做构造函数来用。所有实例共用一个函数对象即可。
	initialize = function(instance, ...) end,

	static = {
		-- 创建实例
		allocate = function(aClass)
			assert(type(aClass) == 'table', "Make sure that you are using 'Class:allocate' instead of 'Class.allocate'")
			return setmetatable({ class = aClass }, aClass.__instanceDict)	-- class的__instanceDict表用作设为实例的metatable以及metatable的__index的值
		end,

		-- 创建实例并初始化
		new = function(aClass, ...)
			assert(type(aClass) == 'table', "Make sure that you are using 'Class:new' instead of 'Class.new'")
			local instance = aClass:allocate()
			instance:initialize(...)
			return instance
		end,

		subclass = function(aClass, name)
			assert(type(aClass) == 'table', "Make sure that you are using 'Class:subclass' instead of 'Class.subclass'")
      		assert(type(name) == "string", "You must provide a name(string) for your class")

			local subclass = _createClass(name, aClass)

			-- 创建子类只继承父类的成员函数，不应继承父类的静态函数
			for name,method in pairs(aClass.__instanceDict) do
				_propagateInstanceMethod(subclass, name, method)
			end

			-- 为子类定义一个缺省的initialize函数，默认调用其父类的initialize函数
			subclass.initialize = function(instance, ...)
				aClass.initialize(instance, ...)
			end

			aClass.subclasses[subclass] = true	-- 标记父类已拥有该子类
			aClass:subclassed(subclass)			-- 回调：创建子类完毕

			return subclass
		end,

		-- 缺省实现 创建子类完毕回调
		subclassed = function(aClass, other) end,

		-- 判断是否指定类的子类
		isSubclassOf = function(aClass, other)
      		return type(other) == 'table' and
            	   type(aClass.super) == 'table' and
             	   ( aClass.super == other or aClass.super:isSubclassOf(other) )
    	end,

    	-- 批量include
    	include = function(aClass, ...)
      		assert(type(aClass) == 'table', "Make sure you that you are using 'Class:include' instead of 'Class.include'")
      		for _,mixin in ipairs({...}) do
      			_includeMixin(aClass, mixin)
      		end
      		return aClass
    	end
	},
}

function middleclass.class(name, super)
	assert(type(name) == 'string', "A name (string) is needed for the new class")
	return super and super:subclass(name) or _includeMixin(_createClass(name), DefaultMixin)
end

-- 模拟oop class关键字的风格
setmetatable(middleclass, { __call = function(_, ...) return middleclass.class(...) end} )

return middleclass
复制
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
---Animal---
local Class = require 'middleclass'

local Animal = Class('Animal')

function Animal:initialize(name)
	self.instance_name = name
end

function Animal:get_name1()
	return self.instance_name
end

function Animal:move()
	print('Animal:move')
end

function Animal:eat()
	print('Animal:eat!')
end

return Animal
复制
1
2
3
4
5
6
7
8
9
10
11
---Dog---
local Class = require 'middleclass'
local Animal = require 'Animal'

local Dog = Class('Dog', Animal)

function Dog:move()
	print('Dog:move walking!')
end

return Dog
复制

测试：

1
2
3
4
5
6
7
8
9
10
11
12
13
---test---
local Animal = require 'Animal'
local Dog = require 'Dog'

print(Dog:isSubclassOf(Animal))	-- true

local dog = Dog('hashiqi')

print('dog_name:'..dog:get_name1())		-- dog_name:hashiqi
dog:eat()	-- Animal:eat!
dog:move()	-- Dog:move walking!

return dog
复制

继承成员函数

middleclass 的做法是把 super 中的所有成员函数在每个子类中都复制一份

  1. 创建 subclass 时，会调用_propagateInstanceMethod 把当时 super 中所有成员函数复制到 subclass 中
  2. super 声明新函数时，会把该新函数在 super 所有子类中的__instanceDict 表中也复制一份

    实际应用中大部分都是先完整的声明完 super，再去创建其 subclass。 否则的话，super 声明新函数时，会先通过 subclass 中的 \__declaredMethods 判断 subclass 是否声明过该函数 若没有声明，将这个函数复制到 subclass 中的 \__instanceDict 表中，否则不做处理。

__declaredMethods 表中记录的是通过声明创建的函数，__instanceDict 表中记录了所有的函数：声明得到的，以及从所有父类那里复制得到的

基于上述做法，每个子类中的__instanceDict 都包含了其所有父类的__instanceDict 的集合。即子类拥有父类函数。
如果子类重新定义了一个同名函数，那么将覆盖掉父类函数。
子类可以通过 super 关键字来调用函数的父类版本

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
---middleclass---
local middleclass = {}

-- 整合用户指定的__index函数
local function _createIndexWrapper(aClass, f)
	if f == nil then
		return aClass.__instanceDict
	else
	    return function(self, name)
		    local value = aClass.__instanceDict[name]

		    if value ~= nil then
		      	return value
		    elseif type(f) == "function" then
		      	return (f(self, name))
		    else
		      	return f[name]
		    end
	    end
  	end
end

local function _propagateInstanceMethod(aClass, name, f)
	-- 创建子类的时候，父类中__instanceDict的__index会把子类中__instanceDict的__inex覆盖掉
	-- 当用户尝试声明__index函数时，需要做一些处理：保留class.__instanceDict作为实例的__index表，整合用户指定的__index函数/表
	f = name == "__index" and _createIndexWrapper(aClass, f) or f

	-- 新定义的函数将被添加为成员函数
	aClass.__instanceDict[name] = f

	-- 将所有没有声明该函数的（即__declaredMethods表没有该函数）子类的__instanceDict表中记录该函数
	for subclass in pairs(aClass.subclasses) do
	    if rawget(subclass.__declaredMethods, name) == nil then
	    	_propagateInstanceMethod(subclass, name, f)
	    end
	end
end

local function _declareInstanceMethod(aClass, name, f)
	aClass.__declaredMethods[name] = f 	-- 记录到__declaredMethods表

	-- 揭示了middleclass的一个小技巧。当执行 ClassA.func = nil代码时
    -- 会尝试从父类获取同名成员函数来用
	if f==nil and aClass.super then
		f = aClass.super.__instanceDict[name]
	end

	_propagateInstanceMethod(aClass, name, f)
end

local function _tostring(aClass)
	return 'class '..aClass.name
end

local function _call(aClass, ...)
	return aClass:new(...)
end

local function _createClass(name, super)
	local dict = {}
	dict.__index = dict

	local aClass = {
		name = name,	-- 类名
		super = super, 	-- 父类
		static = {},	-- 静态函数表，包括一些关键字比如new，在middleclass中是用静态函数来模拟
		__instanceDict = dict,	-- 用作设为实例的metatable以及metatable的__index的值
		subclasses = setmetatable({}, {__mode='k'}),	-- 子类表(弱键引用)，key是类，value为布尔
		__declaredMethods = {},	-- 用来记录在这个类中声明(而不是继承自父类)的函数
	}

	-- aClass.static的__index行为: 从aClass.__instanceDict进行rawget
	-- 其实__instanceDict没有自己的metatable，从而没有__index表，任何对__instanceDict的get都是rawget
	-- 如果有父类的话，还会尝试去父类(进而沿着继承链上所有类定义)的static/__instanceDict 中查询
	if super then
		setmetatable(aClass.static, {__index = function(_, k)
			return rawget(dict, k) or super.static[k]
		end})
	else
		setmetatable(aClass.static, {__index = function(_, k)
			return rawget(dict, k)
		end})
	end

	setmetatable(aClass, {
		__tostring = _tostring, 	-- 设置aClass的元方法__tostring
		__index = aClass.static,	-- class的索引表设为其static表，如此class对象可以访问其static中的函数以及__instanceDict中的raw函数
		__newindex = _declareInstanceMethod,
		__call = _call,	-- 让我们可以用 ClassA()的写法来创建实例
	})

	return aClass
end

-- 导入mixin
local function _includeMixin(aClass, mixin)
	assert(type(mixin)=='table', 'mixin must be a table.')

	-- 将mixin的所有值复制到aClass中
	-- 除了included，这个名字默认是保留给mixin的回调
	-- 还要排除static表，因为不能简单的记录static引用，这会覆盖aClass现有的static表
	for name,method in pairs(mixin) do
		if name ~= 'included' and name ~= 'static' then
			aClass[name] = method	-- 记住现在这个操作会触发_declareInstanceMethod函数
		end
	end

	-- 把mixin.static表内容添加到aClass.static中
	for name,method in pairs(mixin.static or {}) do
		aClass.static[name] = method
	end

	-- 执行mixin included回调
	if type(mixin.included) == 'function' then
		mixin:included(aClass)
	end

	return aClass
end

local DefaultMixin = {
	-- 没有记录在static中的函数将在class导入DefaultMixin的时候
	-- 通过aClass[name] = func这样的语句触发 _declareInstanceMethod
	-- 从而记录到aClass.__instanceDict中
	-- 由于aClass.__instanceDict同时还是实例对象的metatable，所以下面的__tostring也将成为实例对象的元函数
	__tostring = function(instance)
		return "instance of " .. tostring(instance.class)
	end,

	-- 预留虚函数: 初始化，可以当做构造函数来用。所有实例共用一个函数对象即可。
	initialize = function(instance, ...) end,

	isInstanceOf = function(instance, aClass)
		return type(aClass) == 'table' and
				type(instance) == 'table' and
				type(instance.class) == 'table' and
				(
				instance.class == aClass or 
				type(instance.class.isSubclassOf) == 'function' and instance.class:isSubclassOf(aClass)
				)
	end,

	static = {
		-- 创建实例
		allocate = function(aClass)
			assert(type(aClass) == 'table', "Make sure that you are using 'Class:allocate' instead of 'Class.allocate'")
			return setmetatable({ class = aClass }, aClass.__instanceDict)	-- class的__instanceDict表用作设为实例的metatable以及metatable的__index的值
		end,

		-- 创建实例并初始化
		new = function(aClass, ...)
			assert(type(aClass) == 'table', "Make sure that you are using 'Class:new' instead of 'Class.new'")
			local instance = aClass:allocate()
			instance:initialize(...)
			return instance
		end,

		subclass = function(aClass, name)
			assert(type(aClass) == 'table', "Make sure that you are using 'Class:subclass' instead of 'Class.subclass'")
      		assert(type(name) == "string", "You must provide a name(string) for your class")

			local subclass = _createClass(name, aClass)

			-- 创建子类只继承父类的成员函数，不应继承父类的静态函数
			for name,method in pairs(aClass.__instanceDict) do
				_propagateInstanceMethod(subclass, name, method)
			end

			-- 为子类定义一个缺省的initialize函数，默认调用其父类的initialize函数
			subclass.initialize = function(instance, ...)
				aClass.initialize(instance, ...)
			end

			aClass.subclasses[subclass] = true	-- 标记父类已拥有该子类
			aClass:subclassed(subclass)			-- 回调：创建子类完毕

			return subclass
		end,

		-- 缺省实现 创建子类完毕回调
		subclassed = function(aClass, other) end,

		-- 判断是否指定类的子类
		isSubclassOf = function(aClass, other)
      		return type(other) == 'table' and
            	   type(aClass.super) == 'table' and
             	   ( aClass.super == other or aClass.super:isSubclassOf(other) )
    	end,

    	-- 批量include
    	include = function(aClass, ...)
      		assert(type(aClass) == 'table', "Make sure you that you are using 'Class:include' instead of 'Class.include'")
      		for _,mixin in ipairs({...}) do
      			_includeMixin(aClass, mixin)
      		end
      		return aClass
    	end
	},
}

function middleclass.class(name, super)
	assert(type(name) == 'string', "A name (string) is needed for the new class")
	return super and super:subclass(name) or _includeMixin(_createClass(name), DefaultMixin)
end

-- 模拟oop class关键字的风格
setmetatable(middleclass, { __call = function(_, ...) return middleclass.class(...) end} )

return middleclass
复制
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
---Animal---
local Class = require 'middleclass'

local Animal = Class('Animal')

function Animal:initialize(name)
	self.instance_name = name
end

function Animal:get_name1()
	return self.instance_name
end

function Animal:move()
	print('Animal:move')
end

function Animal:eat()
	print('Animal:eat!')
end

return Animal
复制
1
2
3
4
5
6
7
8
9
10
11
---Dog---
local Class = require 'middleclass'
local Animal = require 'Animal'

local Dog = Class('Dog', Animal)

function Dog:move()
	print('Dog:move walking!')
end

return Dog
复制

测试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
---test---
local Animal = require 'Animal'
local Dog = require 'Dog'

print(Dog:isSubclassOf(Animal))	-- true

local dog = Dog('hashiqi')

print('dog_name:'..dog:get_name1())		-- dog_name:hashiqi
dog:eat()	-- Animal:eat!
dog:move()	-- Dog:move walking!

print(dog:isInstanceOf(Dog))	-- true
print(dog:isInstanceOf(Animal))	-- true

return dog
复制